surface: Always dd events to the profiler trace

We want to get this data for release builds as well.

frame clock: Redo the profiler marks

Instead of reporting the frame clock phases as defined,
report the duration of the signal emissions, which is more
useful for tracking down what is taking time.

ci: Save syscap files from performance tests

They might become useful at some point.

window: Rename a profiler mark

The "layout" name was already taken for the frame clock
phase by that name. Oops.

wayland: Add profiler marks around surface handling

Add marks for when we do commits, swap buffer or
receive frame events. These are the low-level start
and end points of the frame cycle, and it is useful
to see them in the profiler.

surface: Add enter/leave events to profiler traces

These are just as likely to trigger extra work than
other mouse events, so it is useful to show them.

icontheme: Add profiler marks for loading icons

This helps to clearly identify the places where we
do IO, in profiler traces.

Update Japanese translation

Update Japanese translation

Merge branch 'wip/jimmac/typography-classes' into 'master'

Adwaita: general typography classes

Closes #1808

See merge request GNOME/gtk!1339

Adwaita: general typography classes

- many moons and some iterations later, these are the suggested
  general typographic styles. Already being referenced in apps like
  Banner Viewer (for now shipping custom definitions)

Fixes https://gitlab.gnome.org/GNOME/gtk/issues/1808

testsuite: Move the meson performance tests up

Since the binary is moved, there is no need for
the subdirectory here anymore.

Make the performance testcase more general

Reuse the performance test for layout and snapshot timings.

css: Make performance test more flexible

Allow to specify the name of the mark that we're looking
for the first instance of.

widget: Add profiler marks

This gives high-level entries for the duration of
snapshotting and layout in the frame cycle.

window: Add a profiler mark around size allocation

This give a high-level entry for the duration of size allocation
in the frame cycle.

container: Remove an unnecessary check

GtkWindow implements GtkRoot, so we can avoid
treating them separately.

Merge branch 'matthiasc/perf-tests' into 'master'

Performance tests

See merge request GNOME/gtk!1338

testsuite: Make performance test fail

If a child process exits unsuccessfully,
make the performance test fail.

testsuite: Point performance tests at uninstalled schemas

widget-factory won't run otherwise.

Use the v9 image for ci runs

The v9 image add sysprof-devel, so we can build
and run performance tests using libsysprof.

ci: Build with profiler support

This will let us run sysprof-based performance tests.

ci: Add sysprof-devel to the image

We need it to build with profiler support.

Fix testsuite without -Dprofiler=true

Only build and run the performance tests if we have sysprof.

Run the css performance test in the testsuite

The numbers just end up in the testlog for now.

Prototype a sysprof helper

This is an attempt to see how we can use sysprof data
in our tests to extract useful performance numbers.

Use it as a wrapper around any GTK+ process:

./testperf ./gtk4-widget-factory

Currently, it repeatedly runs the given commandline,
extracts the first css validation time from the resulting
syscap file, and prints out the min/max/avg of the runs
at the end.

This relies on the environment variable GTK_DEBUG_AUTO_QUIT
to cause the process to exit soon after launch.

widget-factory: Add a way to quit automatically

This can be used to measure startup cost in tests.

gdk: Make profiler support unconditional

We are still not providing samples unless debugging is enabled.
That needs a bit more work.

cssnode: Make the profiler support unconditional

Merge branch 'otte/for-master' into 'master'

selector: Add GtkSelectorCategory

See merge request GNOME/gtk!1337

selector: Add GtkSelectorCategory

This will make it easier to write more complex matching algorithms.

Merge branch 'otte/for-master' into 'master'

Otte/for master

See merge request GNOME/gtk!1336

stylecontext: Remove excess gtk_css_node_invalidate() call

This call is not necessary, because gtk_css_node_set_parent() does the
right thing. (It probably hasn't been necessary for years, but I'm
not gonna try my luck on GTK3 at this stage.)

This code is usually called the first time
gtk_widget_get_style_context() is called on a widget and its style
context gets create. At that point however, the css nodes are in the
right place already, so no invalidation should happen.

Merge branch 'otte/for-master' into 'master'

Otte/for master

See merge request GNOME/gtk!1333

win32: Don't save/restore the context for querying the font

Use the font in the current state.

widget: Remove gtk_widget_get_path()

cssnode: Remove unused widget path vfuncs

containter: Remove gtk_container_get_path_for_child()

stylecontext: Change semantics of gtk_style_context_get_path()

Widget contexts now return NULL here. A non-NULL result requires a
previous call to gtk_style_context_set_path()

widget: Initialize cssnode name asap

That way, it's correct in subclass's init functions.

Merge branch 'matthiasc/for-master' into 'master'

Add some static assertions

See merge request GNOME/gtk!1334

Add some static assertions

Add assertions that ensure the relationships between
css property IDs that we rely on are preserved.

Add profiler support for css validation

Push numbers about css validation and style creation
to sysprof.

textview: Make cursor work when blinking is disabled

cssselector: Inline a few things

style cascade: Remove some pointless casts

The casts and checks in gtkstylecascade.c are leftovers
from when we had GtkStyleProviderPrivate, and no longer
serve any purpose.

pick: Take advantage of transform categories

Transform categories let us easily avoid doing matrix math
when we can just do a simple translation.

Refactor gtk_widget_pick

Split this into a recursive part and a public
entry point. This lets us avoid some duplicate
checks.

Update Polish translation

css: Redo the pseudoclass selectors

There is no need to duplicate the classes, we can make
do with a single class for all the states.

css: Go back to clearing out selectors

Now that we use the selector tree for change computation
again, we don't need the ruleset selectors anymore.
Bring back the code that cleans them out.

Update Croatian translation

Update Croatian translation

Refine the selector tree printing

Also show which tree nodes have exact matches.

Fix a css change testcase

The ui file here was invalid, leading to nonsensical
results.

Actually turn of css value accounting

We need an #undef here. While doing so, make sure
it compiles without warnings when disabled.

inspector: Avoid an array overrun

Commit 3f56af373891bf6e3 added a new value to the
GdkInputSource enum, forgetting that the inspector
has an array of names to match this enum.

Fixes: https://gitlab.gnome.org/GNOME/gtk/issues/2385

wayland: Fix release build warnings

x11: Fix release build warnings

Update POTFILES.skip

gl renderer: Pull a local variable in the closest scope

cssimagefallback: Don't snapshot invisible colors

This avoids a few render nodes later.

widget: Get opacity without GtkStyleContext

GtkStyleContext is really just unnecessary here.

cssstyle: set font variations in get_pango_font()

Doesn't make sense to set all the css values on the font description in
there except for the font variations, so do these here as well.

widget: Get DPI from style directly

Instead of going through GtkStyleContext.

cssstyle: Implement get_pango_font() directly

Instead of going through the slow GValue code path. This function was
unused, so use it in GtkWidget's update_pango_context() now.

testsuite: Update expected css errors

gl renderer: Draw outset shadows white

and only apply the actual shadow color when we draw them from the
texture. This way we can reuse the cached shadows during color
transitions.

css: Mark transform value as computed

This is not very useful, since transitions generate
a ton of transforms anyway.

css: Simplify default values

We no longer need to create one-element arrays or
corners with two identical values.

css: Re-add a lost special case

When the border-style special cases were moved in
c687f485fdd0a, the one for outline-width was lost.

Make the code more compact, and bring the special
case back.

csshorthandproperty: Try to avoid allocating a GString for 1 font

cssdimensionvalue: remove early-out code from transition()

We do this directly in gtk_css_value_transition() now

gl renderer: Render simple border nodes in a simple way

Roughly 80% of the border nodes are just one color and have the same
width on all sides, so we can draw them by uploading just one rect and
not four.

numbervalue: Add early-out to multiply()

If the factor is 1, we already know what the result is going to be.

cssnumbervalue: Move early-out code to GtkCssValue

These checks make sense for all css values.

cssdimensionvalue: Implement transition()

Instead of falling back to the generic gtk_css_number_value_transition
(which can allocate multiple new css values), just implement this here.

Remove GtkCssShadowsValue

Previously, we wrapped all GtkCssShadowValues in a GtkCssShadowsValue,
even if it was just one shadow. This causes an unnecessary bloat in
css values.

Make each GtkCssShadowValue able to handle multiple shadows instead, and
use gtk_css_shadow_value* API everywhere.

cssshadowvalue: Only create 2 shadows values for transitions

This is for cases where we want to transition from "no shadow" to
"shadow", which we need quite a lot.

cssvalue: Improve css value accounting output

And make it fully optional behind an #ifdef.

csscolorvalue: check for singletons in new_literal

Gets rid of another ~400 GtkCssValue instances in the widget-factory.

cssimage: Add is_computed vfunc

Same semantics as the is_computed field of GtkCssValue

css: Set the is_computed flag for more values

With these changes, we skip roughly 85% of compute() calls during
widget-factory startup

cssvalue: Don't call compute() for already computed css values

As per the previous commit, this is unnecessary.

Even with the small amount of css values we mark as is_computed, we
already skip computing over 60% of them like this during the startup of
the widget factory.

cssvalue: Add is_computed flag

When a css value has "child" css values (e.g. a linear gradient has
several color stop css values) which are all computed (won't change when
compute() is called on them), we want to skip computing the entire
subtree.

Since css values are immutable, we can set the is_computed flag at
construct time.

Since GtkCssValue instances are 0-initialized in _gtk_css_value_alloc,
the default for is_computed it FALSE. This commit only sets it to TRUE
in a few cases, such as various "none" singleton values which will never
change. Later commits will refine this and set it for more values.

testsuite: Update css color output

css: Move border-width special cases out of GtkCssDimensionValue

Move them to style computation instead, so we don't have them in such a
generic place.

csscolorvalue: Don't copy rgbas when applying function

We get const pointers to the colors, so just use those and unref the
values later.

gl renderer: Look at shadow color in the outset shadow cache

It would probably be better to not do this and always render the outline
in plain white, then later recolor it but do this for no, just for
correctness.

cssimageradial: Use array + length instead of GArray

This makes sense since we're not going to change the (amount of) colors
after parsing.

cssimagelinear: Use count+array for the color stops, not GArray

This makse sense but will also make later changes to GtkCssImageLinear
simpler.

cssimagefallback: Don't compute new image if only a color is set

Themes might use e.g. image(red), which is a constant value and will
never change. In that case, the fallback image has ->color set, but not
->images. If that's the case and the computed color is the same as
the one we already have, just return the already existing image.

Remove GtkCssRgbaValue

The differenciation between a literal color value and an RGBA value
caused problems in various situations. Just treat the two the same but
don't allow access to the rgba value of a non-literal color value.

This gets rid of around 1.6k rgba values in the widget-factory.

dump css value stats

csssshadwovalue: Remove unused function prototype

cssnumbervalue: Add early-outs to transition code

we don't need to do the calculation at all if the progress is 0 or 1
anyway.

We also sometimes transition from 0 to 0 etc., so we can short-circuit
that as well by doing the fast pointer-equality check and relying on the
singletons.

csscornervalue: Accept other values if x == y

Most corners are square, so x == y. In that case, just accept either of
them. This makes the corner value unnecessary.

In fact none of the corner values in the widget-factory are needed, so
this spares us around 500 corner value allocations.

css value stats before:

GtkCssBgSizeValue: 23
GtkCssIdentValue: 25
GtkCssPositionValue: 81
GtkCssCornerValue: 556
GtkCssArrayValue: 143
GtkCssStringValue: 33
GtkCssPaletteValue: 29
GtkCssImageValue: 2765
GtkCssColorValue: 1452
GtkCssFilterValue: 3
GtkCssRgbaValue: 1092
GtkCssShadowValue: 708
GtkCssEaseValue: 33
GtkCssBorderValue: 2
GtkCssTransformValue: 11
GtkCssDimensionValue: 882
GtkCssShadowsValue: 584
SUM: 8428

and after:

GtkCssColorValue: 1452
GtkCssFilterValue: 3
GtkCssRgbaValue: 1092
GtkCssShadowValue: 708
GtkCssEaseValue: 33
GtkCssBorderValue: 2
GtkCssTransformValue: 11
GtkCssDimensionValue: 882
GtkCssShadowsValue: 584
GtkCssBgSizeValue: 23
GtkCssIdentValue: 25
GtkCssPositionValue: 81
GtkCssArrayValue: 143
GtkCssStringValue: 33
GtkCssPaletteValue: 29
GtkCssImageValue: 2765
SUM: 7872

8428 to 7872 is a 556 reduction (6.5%)

asdf

cssarrayvalue: Don't allocate memory when parsing array values

We probably won't find CSS with more than 128 values in array.

cssarrayvalue: Allow calling array API on non-arrays

Just allow calling _get_nth() and _get_n_values() on every kind of css
value. This way we can allow all values in places where only array
values would be allowed before.

This spares us around 1000 array values in the widget factory.

css value stats before:

GtkCssFilterValue: 3
GtkCssRgbaValue: 1092
GtkCssShadowValue: 708
GtkCssEaseValue: 33
GtkCssBorderValue: 2
GtkCssTransformValue: 11
GtkCssDimensionValue: 882
GtkCssShadowsValue: 584
GtkCssBgSizeValue: 23
GtkCssIdentValue: 25
GtkCssPositionValue: 81
GtkCssCornerValue: 556
GtkCssArrayValue: 1130
GtkCssStringValue: 33
GtkCssPaletteValue: 29
GtkCssImageValue: 2765
GtkCssColorValue: 1452
SUM: 9415

and after:

GtkCssBgSizeValue: 23
GtkCssIdentValue: 25
GtkCssPositionValue: 81
GtkCssCornerValue: 556
GtkCssArrayValue: 143
GtkCssStringValue: 33
GtkCssPaletteValue: 29
GtkCssImageValue: 2765
GtkCssColorValue: 1452
GtkCssFilterValue: 3
GtkCssRgbaValue: 1092
GtkCssShadowValue: 708
GtkCssEaseValue: 33
GtkCssBorderValue: 2
GtkCssTransformValue: 11
GtkCssDimensionValue: 882
GtkCssShadowsValue: 584
SUM: 8428

9415 to 8428 is a 987 reduction (10.4%)

cssvalue: Add type names for all classes

This is important to have for debugging and e.g. to print statistics for
the individual css value types